﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.Mvc;
using blacksoft.Models;
using System.Threading;
using System.Globalization;
using System.Data.Entity.Core.Objects;
using System.Data.Entity.Validation;
using blacksoft.Constantes;
namespace blacksoft.Controllers
{
    public class VentaController : Controller
    {
        private inf245travelbusEntities db = new inf245travelbusEntities();
        private decimal porc_igv = (decimal)0.19;
        private decimal tipo_cambio = (decimal)2.8;
        private static int DOLARCOMPRA= 1;
        private static int DOLARVENTA = 1;
        private static int EUROCOMPRA = 1;
        private static int EUROVENTA  = 1;

        private class MediosPago
        {
            public string valor { get; set; }
            public string nombre { get; set; }
            public MediosPago(string valor, string nombre)
            {
                this.valor = valor;
                this.nombre = nombre;
            }
        }
        private List<MediosPago> medios_pago = new List<MediosPago> { new MediosPago("Efectivo", "Sólo Efectivo"), new MediosPago("Tarjeta", "Sólo Tarjeta"), new MediosPago("EfectivoTarjeta", "Efectivo y Tarjeta") };

        // GET: /Venta/
        public ActionResult Index(string search_fechpago, string search_codres)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }


            bool global = PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.GLOBAL);
            var ventas = from v in db.Venta
                         where v.Estado != "AN"
                         select v;
            //Local session
            int idTerminal;
            if (!global)
            {
                idTerminal = (int)Session["IDTerminal"];
                ventas = from v in ventas
                         join p in db.Persona on v.IDPersona equals p.IDPersona
                         where p.IDTerminal == idTerminal
                         select v;
            }

            if (!string.IsNullOrEmpty(search_fechpago))
            {
                try
                {
                    DateTime aux_date = Convert.ToDateTime(search_fechpago);
                    ventas = ventas.Where(s => EntityFunctions.TruncateTime(s.FechaPago) == EntityFunctions.TruncateTime(aux_date));
                }
                catch
                {
                    return View(ventas.ToList());
                }
            }
            if (!string.IsNullOrEmpty(search_codres))
            {
                try
                {
                    int aux_codres = int.Parse(search_codres);
                    ventas = ventas.Where(s => s.IDReserva == aux_codres);
                }
                catch
                {
                    return View(ventas.ToList());
                }
            }
            return View(ventas.ToList());
        }

        // GET: /Venta/Details/5
        public ActionResult Details(int? id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (id == null)
            {
                return RedirectToAction("Index");
            }
            Venta venta = db.Venta.Find(id);
            if (venta == null)
            {
                return HttpNotFound();
            }
            return View(venta);
        }

        // GET: /Venta/CreateWithReserve
        public ActionResult Create(string tb_CodRes, string tb_FechaReserva)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }


            bool global = PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.GLOBAL);
            //Seleccionar todas las reservas del día
            var reserva = from u in db.Reserva
                          where u.Estado == "AC"
                          select u;
            //Local session
            int idTerminal;
            if (!global)
            {
                idTerminal = (int)Session["IDTerminal"];
                reserva = from v in reserva
                         join p in db.Pasaje on v.IDReserva equals p.IDReserva 
                         join pv in db.ProgramacionViaje on p.IDProgramacionViaje equals pv.IDProgramacionViaje
                         join r_b in db.Ruta_x_UnidadTransporte on pv.IdRuta_x_UnidadTransporte equals r_b.IdRuta_x_UnidadTransporte
                         join r in db.Ruta on r_b.IDRuta equals r.IDRuta
                         where r.IDTerminal == idTerminal
                         select v;
            }

            if (String.IsNullOrEmpty(tb_CodRes) && String.IsNullOrEmpty(tb_FechaReserva))
                reserva = reserva.Where(s => EntityFunctions.TruncateTime(s.FechaRegistro) == EntityFunctions.TruncateTime(DateTime.Now));

            //Filtrar por CÓDIGO DE RESERVA
            if (!String.IsNullOrEmpty(tb_CodRes))
            {
                try
                {
                    int cod = int.Parse(tb_CodRes);
                    reserva = reserva.Where(s => s.IDReserva.Equals(cod));
                }
                catch
                {
                    return View(reserva);
                }
            }
            //Filtrar por FECHA DE RESERVA
            if (!String.IsNullOrEmpty(tb_FechaReserva))
            {
                try
                {
                    DateTime aux_date = Convert.ToDateTime(tb_FechaReserva);
                    reserva = reserva.Where(s => EntityFunctions.TruncateTime(s.FechaRegistro) == EntityFunctions.TruncateTime(aux_date));
                }
                catch
                {
                    return View(reserva);
                }
            }

            return View(reserva);
        }

        // POST: /Venta/CreateWithReserve
        // Para protegerse de ataques de publicación excesiva, habilite las propiedades específicas a las que desea enlazarse. Para obtener 
        // más información vea http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create(string rb_IdReserva)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (rb_IdReserva != null)
            {
                Session["MODVENTA_IDReserva"] = Convert.ToInt32(rb_IdReserva);
                return RedirectToAction("ReserveConfirmation");
            }

            //Mensaje de Error
            TempData["alertMessage"] = "Debe seleccionar una reserva";

            //Seleccionar todas las reservas del día
            var reserva = from u in db.Reserva
                          select u;
            reserva = reserva.Where(s => EntityFunctions.TruncateTime(s.FechaRegistro) == EntityFunctions.TruncateTime(DateTime.Now));

            return View(reserva);
        }


        // GET: /Venta/ReserveConfirmation
        public ActionResult ReserveConfirmation()
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (Session["MODVENTA_IDReserva"] != null)
            {
                //ID de Reserva a mostrar
                ViewBag.IDReserva = ((int)Session["MODVENTA_IDReserva"]).ToString();

                //////////////////////////////////////////////////////////////////
                //Buscar reserva con el IDReserva seleccionado
                int aux_IDReserva = (int)Session["MODVENTA_IDReserva"];
                Reserva reserva = db.Reserva.Find(aux_IDReserva);
                //Listar pasajes para la reserva seleccionada
                var aux_lst = new List<Pasaje>();
                var qry_pasajes = from p in db.Pasaje
                                  where p.IDReserva == aux_IDReserva
                                  select p;
                aux_lst.AddRange(qry_pasajes.Distinct());
                reserva.Pasaje = aux_lst;
                //////////////////////////////////////////////////////////////////


                return View(reserva);
            }

            //Si nunca se obtuvo el ID de la reserva no se realiza la operación: regreso a Index
            return RedirectToAction("Index");
        }

        // POST: /Venta/ReserveConfirmation
        // Para protegerse de ataques de publicación excesiva, habilite las propiedades específicas a las que desea enlazarse. Para obtener 
        // más información vea http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult ReserveConfirmation(string rb)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            return RedirectToAction("Payment");
        }


        // GET: /Venta/Edit/5
        public ActionResult Edit(int? id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (id == null)
            {
                return RedirectToAction("Index");
            }
            Venta venta = db.Venta.Find(id);
            if (venta == null)
            {
                return HttpNotFound();
            }

            ART_Venta_Edit venta_edit = new ART_Venta_Edit();
            venta_edit.IDART_Venta_Edit = venta.IDVenta;
            venta_edit.Estado = venta.Estado;
            venta_edit.FechaPago = venta.FechaPago;
            venta_edit.IDNotaCredito = venta.IDNotaCredito;
            venta_edit.IDReserva = venta.IDReserva;
            venta_edit.IGV = venta.IGV;
            venta_edit.MedioPago = venta.MedioPago;
            venta_edit.MontoDescuento = venta.MontoDescuento;
            venta_edit.MontoEfectivo = venta.MontoEfectivo;
            venta_edit.MontoNotaCredito = venta.MontoNotaCredito;
            venta_edit.MontoTarjeta = venta.MontoTarjeta;
            venta_edit.Subtotal = venta.Subtotal;
            venta_edit.Total = venta.Total;
            venta_edit.Vuelto = venta.Vuelto;

            var aux_lst = new List<ART_Pasaje>();
            var qry_pasajes = from r in db.Reserva
                              join pj in db.Pasaje on r.IDReserva equals pj.IDReserva
                              where pj.IDReserva == venta.IDReserva
                              select pj;
            foreach (var item in qry_pasajes)
            {
                ART_Pasaje p = new ART_Pasaje();
                p.IDPasaje = item.IDPasaje;
                p.Elegido = false;
                p.DNI = item.DNI;
                p.Almuerzo = item.Almuerzo;
                p.ApellidoMaterno = item.ApellidoMaterno;
                p.ApellidoPaterno = item.ApellidoPaterno;
                p.MontoCosto = item.MontoCosto;
                p.MontoDescuento = item.MontoDescuento;
                p.MontoPago = item.MontoPago;
                p.Nombre = item.Nombre;
                p.NroAsiento = item.NroAsiento;
                p.Refrigerio = item.Refrigerio;
                p.Estado = item.Estado;
                aux_lst.Add(p);
            }

            venta_edit.Pasajes = aux_lst;

            return View(venta_edit);
        }

        // POST: /Venta/Edit/5
        // Para protegerse de ataques de publicación excesiva, habilite las propiedades específicas a las que desea enlazarse. Para obtener 
        // más información vea http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "IDART_Venta_Edit,Pasajes,FechaPago,MontoDescuento,MedioPago,MontoEfectivo,MontoTarjeta,IDNotaCredito,MontoNotaCredito,Subtotal,IGV,Total,Vuelto,Estado,IDReserva")] ART_Venta_Edit art_venta)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (ModelState.IsValid)
            {
                var qry_doc_venta = from dv in db.DocumentoVenta
                                where dv.IDVenta == art_venta.IDART_Venta_Edit
                                select dv;
                DocumentoVenta doc_venta = qry_doc_venta.First();
                List<Pasaje> pasajes = new List<Pasaje>();

                int cant_pasajes = art_venta.Pasajes.Count;
                int contador = 0;
                foreach (var item in art_venta.Pasajes)
                {
                    if (item.Elegido)
                    {
                        contador += 1;
                        //eliminar pasaje
                        Pasaje pasaje = db.Pasaje.Find(item.IDPasaje);
                        pasaje.Estado = "AN";
                        //Emitir nota de crédito del pasaje
                        pasajes.Add(pasaje);
                        //guardar los cambios de la venta
                        db.Entry(pasaje).State = EntityState.Modified;
                    }
                }

                Session["MODVENT_Pasajes_Elminar"] = pasajes;

                if (contador == cant_pasajes)
                {
                    //eliminar venta
                    Venta venta = db.Venta.Find(art_venta.IDART_Venta_Edit);
                    venta.Estado = "AN";
                    db.Entry(venta).State = EntityState.Modified;
                }
                try
                {
                    db.SaveChanges();
                }
                catch
                {
                    TempData["edit_failure"] = "La venta no se pudo modificar";
                    return RedirectToAction("Index");
                }
                TempData["edit_success"] = "La venta modificó exitosamente";
                return RedirectToAction("Index");
                //return RedirectToAction("Show","DocumentoVenta", new { id = doc_venta.IDDocumentoVenta });
            }
            return View(art_venta);
        }

        // GET: /Venta/Delete/5
        public ActionResult Delete(int? id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }            
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Venta venta = db.Venta.Find(id);
            if (venta == null)
            {
                return HttpNotFound();
            }
            return View(venta);
        }

        // POST: /Venta/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            Venta venta = db.Venta.Find(id);

            if (ModelState.IsValid)
            {
                venta.Estado = "AN";

                //eliminar todos los pasajes
                var aux_lst = new List<ART_Pasaje>();
                var qry_pasajes = from r in db.Reserva
                                  join pj in db.Pasaje on r.IDReserva equals pj.IDReserva
                                  where pj.IDReserva == venta.IDReserva && pj.Estado == "AC"
                                  select pj;
                //generar notas de credito a todos los pasajes
                db.Entry(venta).State = EntityState.Modified;
                foreach (var pasaje in qry_pasajes)
                {
                        pasaje.Estado = "AN";
                        //Emitir nota de crédito del pasaje
                        
                        db.Entry(pasaje).State = EntityState.Modified;          
                }
                try
                {
                    db.SaveChanges();
                }
                catch
                {
                    TempData["delete_failure"] = "La venta no se pudo eliminar";
                    return RedirectToAction("Index");
                }
                TempData["delete_success"] = "La venta se eliminó exitosamente";
            }
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }




        public ActionResult PrintPasajes(int? id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Venta venta = db.Venta.Find(id);
            if (venta == null)
            {
                return HttpNotFound();
            }
            return View(venta);
        }













        // GET: /Venta/Payment
        public ActionResult Payment(string CJ_RUC, string IDNota, string chbxNotaCred)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            ViewBag.TipoCambio = VentaController.TIPOCAMBIO(VentaController.DOLARCOMPRA).ToString();

            ViewBag.MedioPago = new SelectList(medios_pago, "valor", "nombre");

            if (Session["MODVENTA_IDReserva"] == null)
            {
                return RedirectToAction("Index");
            }

            ART_Venta venta = new ART_Venta();

            var personas = from p in db.Persona
                           select p;

            if (!string.IsNullOrEmpty(CJ_RUC))
            {
                
                personas = personas.Where(s => s.RUC == CJ_RUC);
                if (personas.Count() == 1)
                {
                    ViewBag.CJ_RUC = personas.First().RUC;
                    ViewBag.CJ_RazonSocial = personas.First().RazonSocial;
                    ViewBag.CJ_Direccion = personas.First().Direccion;
                    ViewBag.CJ_Telefono = personas.First().Telefono.ToString();
                    ViewBag.CJ_Email = personas.First().Email;
                    Session["MODVENTA_CJ"] = personas.First();
                    Session["MODVENTA_CJ_RUC"] = CJ_RUC;
                }
                else
                {
                    ViewBag.CJ_RUC = "";
                    ViewBag.CJ_RazonSocial = "";
                    ViewBag.CJ_Direccion = "";
                    ViewBag.CJ_Telefono = "";
                    ViewBag.CJ_Email = "";
                    Session["MODVENTA_CJ"] = null;
                    Session["MODVENTA_CJ_RUC"] = null;
                    ModelState.AddModelError("ErrorEmpresaNull", "El cliente no está registrado");
                }
            }

            if (!string.IsNullOrEmpty(IDNota))
            {
                //Buscar nota de credito y excluir las no existentes
                if (Convert.ToBoolean(chbxNotaCred)) //si no se usa nota de crédito, no entrar
                {
                    try
                    {
                        int dummy = Convert.ToInt32(IDNota);
                    }
                    catch
                    {
                        ModelState.AddModelError("ErrorNotaCredNull", "Ingrese un dato válido");
                        return View(venta);
                    }
                    NotaCredito nota_cred = db.NotaCredito.Find(Convert.ToInt32(IDNota));
                    
                    if (nota_cred == null)
                    {
                        ModelState.AddModelError("ErrorNotaCredNull", "La Nota de Crétido no existe");
                        return View(venta);
                    }
                    if (nota_cred.FechaLimite < DateTime.Now.Date)
                    {
                        ModelState.AddModelError("ErrorNotaCredNull", "La Nota de Crétido ya venció");
                        return View(venta);
                    }
                    //La nota es valida
                    ViewBag.IDNota = IDNota;
                    ViewBag.MontoNota = nota_cred.Total.ToString();
                    Session["MODVENTA_IDNota"] = nota_cred.IDNotaCredito;
                    Session["MODVENTA_MontoNota"] = nota_cred.Total;
                }
                else
                {
                    Session["MODVENTA_IDNota"] = null;
                    Session["MODVENTA_MontoNota"] = null;
                }
            }

            //////////////////////////////////////////////////////////////////
            //Buscar reserva con el IDReserva seleccionado
            int aux_IDReserva = (int)Session["MODVENTA_IDReserva"];
            Reserva reserva = db.Reserva.Find(aux_IDReserva);
            //Listar pasajes para la reserva seleccionada
            var aux_lst = new List<Pasaje>();
            var qry_pasajes = from p in db.Pasaje
                              where p.IDReserva == aux_IDReserva
                              select p;
            //////////////////////////////////////////////////////////////////

            //////////////////////////////////////////////////////////////////
            //Obtener monto a pagar total por todos los pasajes
            decimal? monto_pago_total = 0;
            decimal? monto_descuento_total = 0;

            foreach (var pj in qry_pasajes)
            {
                //acumular pagos
                monto_pago_total += pj.ProgramacionViaje.Precio;

                //--------------------------------------DESCUENTOS-----------------------------------//
                //Buscar promocion asociada al viaje de cada pasaje
                var qry_promocion = from pv in db.ProgramacionViaje
                                    join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                    join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                    where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                    select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                if (qry_promocion != null)
                {
                    //Por cada promocion, verificar la fecha de fin 
                    foreach (var prom in qry_promocion)
                    {
                        //Si es menor realizar descuento
                        if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                        {
                            //Buscar el tipo de persona/cliente para saber si la promoción es aplicable o no
                            Persona cliente = db.Persona.Find(pj.IDPersona);
                            //Verificar que el descuento se aplica al tipo de cliente
                            if (prom.TipoCliente == cliente.TipoPersona)
                            {
                                //si el cliente tiene puntaje para invertir
                                if (cliente.PuntosAcumulados >= prom.PuntosRequeridos)
                                {
                                    //acumular descuento
                                    monto_descuento_total += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                    //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                    if (monto_descuento_total > monto_pago_total)
                                    {
                                        monto_descuento_total = monto_pago_total;
                                        break;
                                    }
                                }
                            }
                        }
                    }

                }
            }
            venta.MontoDescuento += Math.Round((decimal)monto_descuento_total, 2);
            venta.Total += monto_pago_total;
            venta.Vuelto += 0;
            //////////////////////////////////////////////////////////////////

            //------------------------------------------------------------------------------------------------------------------------------------//

            //////////////////////////////////////////////////////////////////
            //Buscar reserva de vuelta
            int aux2_idres = (int)Session["MODVENTA_IDReserva"];
            var qry_res_vuelta = from p in db.Reserva
                                 where p.IdAnexo == aux2_idres
                                 select p;
            if (qry_res_vuelta.Count() > 0)
            {
                //Asignarle los puntos asociados
                int aux2_idres_vuelta = qry_res_vuelta.First().IDReserva;
                //Listar pasajes para la reserva seleccionada
                var aux2_lst = new List<Pasaje>();
                var qry_pasajes2 = from p in db.Pasaje
                                   where p.IDReserva == aux2_idres_vuelta
                                   select p;
                //////////////////////////////////////////////////////////////////

                //////////////////////////////////////////////////////////////////
                //Obtener monto a pagar total por todos los pasajes
                decimal? monto_pago_total2 = 0;
                decimal? monto_descuento_total2 = 0;

                foreach (var pj in qry_pasajes2)
                {
                    //acumular pagos
                    monto_pago_total2 += pj.ProgramacionViaje.Precio;

                    //--------------------------------------DESCUENTOS-----------------------------------//
                    //Buscar promocion asociada al viaje de cada pasaje
                    var qry_promocion = from pv in db.ProgramacionViaje
                                        join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                        join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                        where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                        select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                    if (qry_promocion != null)
                    {
                        //Por cada promocion, verificar la fecha de fin 
                        foreach (var prom in qry_promocion)
                        {
                            //Si es menor realizar descuento
                            if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                            {
                                //Buscar el tipo de persona/cliente para saber si la promoción es aplicable o no
                                Persona cliente = db.Persona.Find(pj.IDPersona);
                                //Verificar que el descuento se aplica al tipo de cliente
                                if (prom.TipoCliente == cliente.TipoPersona)
                                {
                                    //si el cliente tiene puntaje para invertir
                                    if (cliente.PuntosAcumulados >= prom.PuntosRequeridos)
                                    {
                                        //acumular descuento
                                        monto_descuento_total2 += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                        //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                        if (monto_descuento_total2 > monto_pago_total2)
                                        {
                                            monto_descuento_total2 = monto_pago_total2;
                                            break;
                                        }
                                    }
                                }
                            }
                        }

                    }
                }
                venta.MontoDescuento += Math.Round((decimal)monto_descuento_total2, 2);
                venta.Total += monto_pago_total2;
                venta.Vuelto += 0;
            }
            //////////////////////////////////////////////////////////////////

            return View(venta);
        }


        // POST: /Venta/Payment
        // Para protegerse de ataques de publicación excesiva, habilite las propiedades específicas a las que desea enlazarse. Para obtener 
        // más información vea http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        //ClienteJ,
        public ActionResult Payment([Bind(Include = "IDVenta,IDNotaCredito,MontoDolares,MontoTarjeta,MontoNotaCredito,Total,MedioPago,MontoDescuento,MontoSoles,Vuelto")]ART_Venta venta)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            Persona empresa = new Persona();
            Venta aux_venta = new Venta();

            decimal? monto_pago_total = 0;
            decimal? monto_descuento_total = 0;
            if (ModelState.IsValid)
            {
                Persona per_clientej = (Persona)Session["MODVENTA_CJ"];
                //Buscar al cliente juridico
                if (per_clientej != null)
                {
                    var aux_per = from p in db.Persona
                                  where per_clientej.RUC == p.RUC && per_clientej.RazonSocial == p.RazonSocial
                                  select p;

                    //Si el Cliente Empresa ya existe en el sistema, procesarlo
                    if (aux_per.Count() > 0)
                    {
                        //--------------------------------------PASAJES DE IDA-----------------------------------//
                        //Asignarle los puntos asociados
                        int aux_idres = (int)Session["MODVENTA_IDReserva"];
                        var qry_pjCJ = from p in db.Pasaje
                                       where p.IDReserva == aux_idres
                                       select p;
                        foreach (var pj in qry_pjCJ)
                        {
                            //--------------------------------------PUNTAJES-----------------------------------//
                            //búsqueda del puntaje a ganar
                            var puntosAGanar = from pv in db.ProgramacionViaje
                                               join rxt in db.Ruta_x_UnidadTransporte on pv.IdRuta_x_UnidadTransporte equals rxt.IdRuta_x_UnidadTransporte
                                               join r in db.Ruta on rxt.IDRuta equals r.IDRuta
                                               where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                               select r.PuntosAGanar*r.Distancia;
                            //Suma de puntaje 
                            empresa = db.Persona.Find(aux_per.First().IDPersona);
                            try
                            {
                                empresa.PuntosAcumulados += Convert.ToInt32(puntosAGanar.First());
                            }
                            catch
                            {
                                return View(venta);
                            }
                            if (empresa.PuntosAcumulados > 1000) empresa.TipoPersona = 4;
                            //db.Entry(empresa).State = EntityState.Modified;


                            //--------------------------------------DESCUENTOS-----------------------------------//
                            //acumular pagos
                            monto_pago_total += pj.ProgramacionViaje.Precio;
                            //Buscar promocion asociada al viaje de cada pasaje
                            var qry_promocion = from pv in db.ProgramacionViaje
                                                join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                                join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                                where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                                select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                            if (qry_promocion != null)
                            {
                                //Por cada promocion, verificar la fecha de fin 
                                foreach (var prom in qry_promocion)
                                {
                                    //Si es menor realizar descuento
                                    if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                                    {
                                        //Verificar que el descuento se aplica al tipo de cliente
                                        if (prom.TipoCliente == empresa.TipoPersona)
                                        {
                                            //si el cliente tiene puntaje para invertir
                                            if (empresa.PuntosAcumulados >= prom.PuntosRequeridos)
                                            {
                                                //acumular descuento
                                                monto_descuento_total += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                pj.MontoDescuento = pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                empresa.PuntosAcumulados -= prom.PuntosRequeridos;
                                                //db.Entry(empresa).State = EntityState.Modified;
                                                //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                                if (monto_descuento_total > monto_pago_total)
                                                {
                                                    monto_descuento_total = monto_pago_total;
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }

                            }

                            //-------------------------------MODIFICACIONES PASAJES-----------------------------//
                            pj.MontoCosto = pj.ProgramacionViaje.Precio;
                            pj.MontoPago = pj.MontoCosto - pj.MontoDescuento;
                            pj.Estado = "CA";
                            db.Entry(pj).State = EntityState.Modified;
                        }
                        //db.SaveChanges();

                        //-----------------------------------------------------------------PASAJES DE VUELTA-----------------------------------------------------//
                        //Buscar reserva de vuelta
                        int aux2_idres = (int)Session["MODVENTA_IDReserva"];
                        var qry_res_vuelta = from p in db.Reserva
                                             where p.IdAnexo == aux2_idres
                                             select p;
                        //
                        if (qry_res_vuelta.Count() > 0)
                        {
                            //Asignarle los puntos asociados
                            int aux2_idres_vuelta = qry_res_vuelta.First().IDReserva;
                            var qry_pjCJ2 = from p in db.Pasaje
                                            where p.IDReserva == aux2_idres_vuelta
                                            select p;
                            foreach (var pj in qry_pjCJ2)
                            {
                                //--------------------------------------PUNTAJES-----------------------------------//
                                //búsqueda del puntaje a ganar
                                var puntosAGanar = from pv in db.ProgramacionViaje
                                                   join rxt in db.Ruta_x_UnidadTransporte on pv.IdRuta_x_UnidadTransporte equals rxt.IdRuta_x_UnidadTransporte
                                                   join r in db.Ruta on rxt.IDRuta equals r.IDRuta
                                                   where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                                   select r.PuntosAGanar*r.Distancia;
                                //Suma de puntaje 
                                empresa = db.Persona.Find(aux_per.First().IDPersona);
                                try
                                {
                                    empresa.PuntosAcumulados += Convert.ToInt32(puntosAGanar.First());
                                }
                                catch
                                {
                                    return View(venta);
                                }
                                if (empresa.PuntosAcumulados > 1000) empresa.TipoPersona = 4;
                                //db.Entry(empresa).State = EntityState.Modified;


                                //--------------------------------------DESCUENTOS-----------------------------------//
                                //acumular pagos
                                monto_pago_total += pj.ProgramacionViaje.Precio;
                                //Buscar promocion asociada al viaje de cada pasaje
                                var qry_promocion = from pv in db.ProgramacionViaje
                                                    join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                                    join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                                    where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                                    select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                                if (qry_promocion != null)
                                {
                                    //Por cada promocion, verificar la fecha de fin 
                                    foreach (var prom in qry_promocion)
                                    {
                                        //Si es menor realizar descuento
                                        if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                                        {
                                            //Verificar que el descuento se aplica al tipo de cliente
                                            if (prom.TipoCliente == empresa.TipoPersona)
                                            {
                                                //si el cliente tiene puntaje para invertir
                                                if (empresa.PuntosAcumulados >= prom.PuntosRequeridos)
                                                {
                                                    //acumular descuento
                                                    monto_descuento_total += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                    pj.MontoDescuento = pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                    empresa.PuntosAcumulados -= prom.PuntosRequeridos;
                                                    //db.Entry(empresa).State = EntityState.Modified;
                                                    //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                                    if (monto_descuento_total > monto_pago_total)
                                                    {
                                                        monto_descuento_total = monto_pago_total;
                                                        break;
                                                    }
                                                }
                                            }
                                        }
                                    }

                                }

                                //--------------------------------------MODIFICACIONES PASAJES-----------------------------------//
                                pj.MontoCosto = pj.ProgramacionViaje.Precio;
                                pj.MontoPago = pj.MontoCosto - pj.MontoDescuento;
                                pj.Estado = "CA";
                                db.Entry(pj).State = EntityState.Modified;
                            }

                            //--------------------------------------MODIFICAR RESERVA DE VUELTA-----------------------------------//

                            Reserva res_vuelta = db.Reserva.Find(aux2_idres_vuelta);
                            res_vuelta.Estado = "CA";
                            db.Entry(res_vuelta).State = EntityState.Modified;

                            
                        }
                        db.Entry(empresa).State = EntityState.Modified;
                    }
                    //else no considerado porque ya se valido en el GET
                }
                //Si el pagador NO es un Cliente Empresa
                else
                {
                    //Asignarle sus pasajes por cada uno
                    int aux_idres = (int)Session["MODVENTA_IDReserva"];
                    var qry_pjcn = from p in db.Pasaje
                                   where p.IDReserva == aux_idres
                                   select p;
                    foreach (var pj in qry_pjcn)
                    {
                        //--------------------------------------PUNTAJES-----------------------------------//
                        //búsqueda del puntaje a ganar
                        var puntosaganar = from pv in db.ProgramacionViaje
                                           join rxt in db.Ruta_x_UnidadTransporte on pv.IdRuta_x_UnidadTransporte equals rxt.IdRuta_x_UnidadTransporte
                                           join r in db.Ruta on rxt.IDRuta equals r.IDRuta
                                           where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                           select r.PuntosAGanar*r.Distancia;
                        int? puntos = 0;
                        try
                        {
                            puntos = Convert.ToInt32(puntosaganar.First());
                        }
                        catch
                        {
                            return View(venta);
                        }
                        //búsqueda del pasajero asociado
                        Persona cliente = db.Persona.Find(pj.IDPersona);
                        //suma de puntaje
                        cliente.PuntosAcumulados += puntos;
                        if (cliente.PuntosAcumulados > 1000) empresa.TipoPersona = 4;
                        //actualizar en bd
                        db.Entry(cliente).State = EntityState.Modified;

                        //--------------------------------------DESCUENTOS-----------------------------------//
                        //acumular pagos
                        monto_pago_total += pj.ProgramacionViaje.Precio;
                        //Buscar promocion asociada al viaje de cada pasaje
                        var qry_promocion = from pv in db.ProgramacionViaje
                                            join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                            join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                            where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                            select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                        if (qry_promocion != null)
                        {
                            //Por cada promocion, verificar la fecha de fin 
                            foreach (var prom in qry_promocion)
                            {
                                //Si es menor realizar descuento
                                if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                                {
                                    //Buscar el tipo de persona/cliente para saber si la promoción es aplicable o no
                                    Persona cli = db.Persona.Find(pj.IDPersona);
                                    //Verificar que el descuento se aplica al tipo de cliente
                                    if (prom.TipoCliente == cliente.TipoPersona)
                                    {
                                        //si el cliente tiene puntaje para invertir
                                        if (cliente.PuntosAcumulados >= prom.PuntosRequeridos)
                                        {
                                            //acumular descuento
                                            monto_descuento_total += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                            pj.MontoDescuento = pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                            cli.PuntosAcumulados -= prom.PuntosRequeridos;
                                            //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                            if (monto_descuento_total > monto_pago_total)
                                            {
                                                monto_descuento_total = monto_pago_total;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }

                        }

                        //--------------------------------------MODIFICACIONES PASAJES-----------------------------------//
                        pj.MontoCosto = pj.ProgramacionViaje.Precio;
                        pj.MontoPago = pj.MontoCosto - pj.MontoDescuento;
                        pj.Estado = "CA";
                    }
                    //db.SaveChanges();

                    //--------------------------------------------------------PASAJES DE VUELTA------------------------------------------------------------//
                    //Buscar reserva de vuelta
                    int aux2_idres = (int)Session["MODVENTA_IDReserva"];
                    var qry_res_vuelta = from p in db.Reserva
                                         where p.IdAnexo == aux2_idres
                                         select p;
                    //
                    if (qry_res_vuelta.Count() > 0)
                    {
                        //Asignarle los puntos asociados
                        int aux2_idres_vuelta = qry_res_vuelta.First().IDReserva;
                        var qry_pjCJ2 = from p in db.Pasaje
                                        where p.IDReserva == aux2_idres_vuelta
                                        select p;
                        foreach (var pj in qry_pjCJ2)
                        {
                            //--------------------------------------PUNTAJES-----------------------------------//
                            //búsqueda del puntaje a ganar
                            var puntosaganar = from pv in db.ProgramacionViaje
                                               join rxt in db.Ruta_x_UnidadTransporte on pv.IdRuta_x_UnidadTransporte equals rxt.IdRuta_x_UnidadTransporte
                                               join r in db.Ruta on rxt.IDRuta equals r.IDRuta
                                               where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                               select r.PuntosAGanar*r.Distancia;
                            int? puntos = 0;
                            try
                            {
                                puntos = Convert.ToInt32(puntosaganar.First());
                            }
                            catch
                            {
                                return View(venta);
                            }
                            //búsqueda del pasajero asociado
                            Persona cliente = db.Persona.Find(pj.IDPersona);
                            //suma de puntaje
                            cliente.PuntosAcumulados += puntos;
                            if (cliente.PuntosAcumulados > 1000) empresa.TipoPersona = 4;
                            //actualizar en bd
                            db.Entry(cliente).State = EntityState.Modified;

                            //--------------------------------------DESCUENTOS-----------------------------------//
                            //acumular pagos
                            monto_pago_total += pj.ProgramacionViaje.Precio;
                            //Buscar promocion asociada al viaje de cada pasaje
                            var qry_promocion = from pv in db.ProgramacionViaje
                                                join pxpv in db.Promocion_ProgramacionViaje on pv.IDProgramacionViaje equals pxpv.IDProgramacionViaje
                                                join p in db.Promocion on pxpv.IdPromocion equals p.IdPromocion
                                                where pv.IDProgramacionViaje == pj.IDProgramacionViaje
                                                select new { p.FechaFin, p.FechaInicio, p.PorcentajeDescuento, p.PuntosRequeridos, p.TipoCliente };
                            if (qry_promocion != null)
                            {
                                //Por cada promocion, verificar la fecha de fin 
                                foreach (var prom in qry_promocion)
                                {
                                    //Si es menor realizar descuento
                                    if (prom.FechaInicio < DateTime.Now.Date && prom.FechaFin > DateTime.Now.Date)
                                    {
                                        //Buscar el tipo de persona/cliente para saber si la promoción es aplicable o no
                                        Persona cli = db.Persona.Find(pj.IDPersona);
                                        //Verificar que el descuento se aplica al tipo de cliente
                                        if (prom.TipoCliente == cliente.TipoPersona)
                                        {
                                            //si el cliente tiene puntaje para invertir
                                            if (cliente.PuntosAcumulados >= prom.PuntosRequeridos)
                                            {
                                                //acumular descuento
                                                monto_descuento_total += pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                pj.MontoDescuento = pj.ProgramacionViaje.Precio * (decimal)prom.PorcentajeDescuento / 100;
                                                cli.PuntosAcumulados -= prom.PuntosRequeridos;
                                                //si los descuentos acumulados superan al pago solo seran iguales a este en el caso extremo
                                                if (monto_descuento_total > monto_pago_total)
                                                {
                                                    monto_descuento_total = monto_pago_total;
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }

                            }

                            //-------------------------------MODIFICACIONES PASAJES-----------------------------//
                            pj.MontoCosto = pj.ProgramacionViaje.Precio;
                            pj.MontoPago = pj.MontoCosto - pj.MontoDescuento;
                            pj.Estado = "CA";
                        }

                        //--------------------------------------MODIFICAR RESERVA DE VUELTA-----------------------------------//

                        Reserva res_vuelta = db.Reserva.Find(aux2_idres_vuelta);
                        res_vuelta.Estado = "CA";
                        db.Entry(res_vuelta).State = EntityState.Modified;

                        //db.SaveChanges();
                    }
                }

                //--------------------------------------MODIFICAR RESERVA SOLO IDA O IDA-----------------------------------//
                int idres_ida = (int)Session["MODVENTA_IDReserva"];
                Reserva res = db.Reserva.Find(idres_ida);
                res.Estado = "CA";
                db.Entry(res).State = EntityState.Modified;

                //--------------------------------------AGREGAR VENTA-----------------------------------//

                //Llaves involucradas
                aux_venta.IDVenta = venta.IDVenta;
                aux_venta.IDReserva = (int)Session["MODVENTA_IDReserva"];              
                if (Session["MODVENTA_IDNota"] != null)
                {
                    aux_venta.IDNotaCredito = (int)Session["MODVENTA_IDNota"];
                    aux_venta.MontoNotaCredito = (decimal)Session["MODVENTA_MontoNota"];
                    NotaCredito nota_credito = db.NotaCredito.Find(aux_venta.IDNotaCredito);
                    nota_credito.Estado = "US";
                    db.Entry(res).State = EntityState.Modified;
                }
                else
                {
                    aux_venta.IDNotaCredito = null;
                    aux_venta.MontoNotaCredito = 0;
                }

                int id_usuario = (int)Session["IDUsuario"];
                var qry_id_persona = from p in db.Persona
                                     join u in db.Usuario on p.IDPersona equals u.IDPersona
                                     where u.IDUsuario == id_usuario
                                     select p.IDPersona;
                int id_persona = qry_id_persona.First();
                aux_venta.IDPersona = id_persona;

                //Medio de pago y montos parciales
                aux_venta.MedioPago = venta.MedioPago;
                
                aux_venta.MontoSoles = (decimal?)venta.MontoSoles;
                aux_venta.MontoDescuento = monto_descuento_total;
                aux_venta.MontoDolares = (decimal?)venta.MontoDolares;
                aux_venta.MontoTarjeta = venta.MontoTarjeta;
                aux_venta.MontoEfectivo = (decimal?)aux_venta.MontoSoles + (decimal?)aux_venta.MontoDolares * (decimal)VentaController.TIPOCAMBIO(VentaController.DOLARCOMPRA);
                aux_venta.Vuelto = (decimal)venta.Vuelto;
                //Montos totales e IGV
                aux_venta.Total = venta.Total;
                aux_venta.Subtotal = (decimal?)(Convert.ToDouble((decimal)aux_venta.Total / (1 + porc_igv)));
                aux_venta.IGV = aux_venta.Subtotal * porc_igv;

                //Otros campos
                aux_venta.Estado = "CA";
                aux_venta.FechaPago = DateTime.Now;

                if (Session["UnidadDeVenta"] != null)
                    aux_venta.IDUnidadVenta = (int)Session["UnidadDeVenta"];
                else
                    aux_venta.IDUnidadVenta = null;

                //persona juridica
                if (Session["MODVENTA_CJ_RUC"] != null)
                {
                    string ruc = (string)Session["MODVENTA_CJ_RUC"];
                    var idempresa = from p in db.Persona
                                    where p.RUC == ruc
                                    select p.IDPersona;
                    aux_venta.IDPersona_Juridica = idempresa.First();
                }
                else
                {
                    aux_venta.IDPersona_Juridica = null;
                }


                db.Venta.Add(aux_venta);
                
                
                if (Session["MODVENTA_CJ_RUC"] != null) //si el pagador fue una empresa VALIDA
                {                  
                    DocumentoVenta documentoVenta = new DocumentoVenta();
                    documentoVenta.Total = aux_venta.Total;
                    documentoVenta.Subtotal = aux_venta.Subtotal;
                    documentoVenta.FechaPago = aux_venta.FechaPago;
                    documentoVenta.IGV = aux_venta.IGV;
                    documentoVenta.IDVenta = aux_venta.IDVenta;
                    documentoVenta.Estado = "AC";
                    documentoVenta.Venta = aux_venta; //enlace con venta
                    db.DocumentoVenta.Add(documentoVenta);

                        try
                        {
                            db.SaveChanges();// guardamos venta y se genera IDVenta
                        }
                        catch
                        {
                            TempData["create_failure"] = "La venta no se pudo registrar";
                            return RedirectToAction("Index");
                        }
                        TempData["create_success"] = "La venta se registró exitosamente";

                    return RedirectToAction("PrintFactura", new { id = documentoVenta.IDDocumentoVenta });
                }


                try
                {
                    db.SaveChanges();// guardamos venta y se genera IDVenta
                }
                catch
                {
                    TempData["create_failure"] = "La venta no se pudo registrar";
                    return RedirectToAction("Index");
                }
                TempData["create_success"] = "La venta se registró exitosamente";

                //Impresion de PasajeS             
                return RedirectToAction("PrintPasajes", new { id = aux_venta.IDVenta });

            }

            //Cuando el modelo no sea válido, cargar el cliente anteriormente buscado si hubo
            Persona persona = (Persona)Session["MODVENTA_CJ"];
            if (persona != null)
            {
                ViewBag.CJ_RUC = persona.RUC;
                ViewBag.CJ_RazonSocial = persona.RazonSocial;
                ViewBag.CJ_Direccion = persona.Direccion;
                ViewBag.CJ_Telefono = persona.Telefono.ToString();
                ViewBag.CJ_Email = persona.Email;
            }
            //Cuando el modelo no sea válido, cargar la nota anteriormente buscado si hubo
            var  var_idnota = Session["MODVENTA_IDNota"];
            if (var_idnota != null)
            {
                ViewBag.IDNota = (int)Session["MODVENTA_IDNota"]; ;
                ViewBag.MontoNota = (decimal)Session["MODVENTA_MontoNota"];
            }

            ViewBag.MedioPago = new SelectList(medios_pago, "valor", "nombre");

            return View(venta);
        }


        public ActionResult PrintFactura(int? id)
        {
            //NO ESTOY LOGUEADO EN EL SISTEMA
            if (Session["Permisos"] == null)
            {
                TempData["LogueatePrimero"] = SystemField.NO_LOGUEADO;
                return RedirectToAction("Index", "ValidarLogin");
            }
            //ESTOY LOGUEADO PERO NO TENGO PERMISO PARA REALIZAR ESTA ACCION
            if (!PerfilsController.TienePermiso((int)Session["Permisos"], PerfilsController.VENTA))
            {
                TempData["SinPermiso"] = SystemField.SIN_PERMISO;
                return RedirectToAction("Index", "MainPageEmployes");
            }
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            DocumentoVenta documentoventa = db.DocumentoVenta.Find(id);
            if (documentoventa == null)
            {
                return HttpNotFound();
            }
            return View(documentoventa);
        }

        static public float TIPOCAMBIO(int a)
        {
            Usupador lectura = new Usupador("http://www.sbs.gob.pe/app/stats/tc-cv.asp");
            string httpResponse = lectura.HTML;
            string dolarCompra = lectura.SacarContenidoCortando("<td class=\"APLI_fila2\">", "</td>").Trim();
            if (a == VentaController.DOLARCOMPRA) return float.Parse(dolarCompra);
            string dolarVenta = lectura.SacarContenidoCortando("<td class=\"APLI_fila2\">", "</td>").Trim();
            if (a == VentaController.DOLARVENTA) return float.Parse(dolarVenta);
            lectura.avanzarHasta("<td width=\"140\" class=\"APLI_fila3\"> Euro<br />");
            string euroCompra = lectura.SacarContenidoCortando("<td class=\"APLI_fila2\">", "</td>").Trim();
            if (a == VentaController.EUROCOMPRA) return float.Parse(euroCompra);
            string euroVenta = lectura.SacarContenidoCortando("<td class=\"APLI_fila2\">", "</td>").Trim();
            if (a == VentaController.EUROVENTA)   return float.Parse(euroVenta);
            else return 0;
        }


    }
}
